#include "Utils.h"

void initB(ByteSequence* B)
{
	B->start =0;
	B->end = 0;
}

int isEmptyU(ByteSequence* B)
{
	if(B->start == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void push(ByteSequence* B, NoByte* no)
{
	if(isEmptyU(B))
	{
		B->start = no;
		B->end = no;
	}
	else
	{
		no->next = 0;
		B->end->next = no;
		B->end = no;
	}
}

//NoByte* getStart(ByteSequence* B)
//{
//	return B->start;
//}

int getNextBitValue(ByteSequence* B)
{
	NoByte *noAux;
	int bit;

	if(!isEmptyU(B)) //se a lista nao ta vazia
	{
		if(B->start->last == BYTE) //se nao tem mais bits a serem lidos
		{
			noAux = B->start;
			B->start = B->start->next;
			if(noAux)
				free(noAux);
		}

		if(B->start != 0) //ainda tem bits a serem lidos
		{
			bit = bitValue(B->start->byte, B->start->last);
			B->start->last += 1; //incrementa para indicar o proximo bit a ser lido nesse no
			return bit;
		}
		else //acabou a lista de bytes
		{
			return -1;
		}
	}
	else //lista vazia
	{
		return -1;
	}
}

int bitValue(char byte, int position)
{
	int pot;
	int number =0;
	char numberChar;

	pot = BYTE -1;

	pot = pot - position;

	number = (int) pow(2, pot);
	numberChar = (char) number;

	if((numberChar & byte) != 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

char* intToString(unsigned char codeHuff, int codeHuffTam)
{
    int i;
    int bit;
    char *string;

    if(codeHuffTam > 0)
    {
        string = (char*) malloc(sizeof(char)*(BYTE+1));
        string[0]='\0';

        for(i=BYTE-codeHuffTam; i< BYTE-1; i++)
        {
            bit = bitValue(codeHuff, i);
            if(bit ==1)
            {
                strcat(string, "1");
            }
            else
            {
                strcat(string, "0");
            }
        }
        return string;
    }
    else
    {
        return "0";
    }
}

char stringBinToByte(const char* string)
{
    int tam = strlen(string);
    int i, ind;
    unsigned char byte=0, byteAux=0;

    ind =0;
    for(i=tam-1; i>=0; i--)
    {
        byteAux = (unsigned char)pow(2, ind);

        if(string[i] == '1')
        {
            byte = byte | byteAux;
        }

        ind++;
    }

    return byte;
}

//char* intToChar(int n, int tamanho)
//{
//    int c, d, count;
//    char *binario;
//
//    count = 0;
//    binario = (char*)malloc(tamanho+1);
//
//    for (c = tamanho-1; c>=0; c--)
//    {
//        d = n >> c;
//
//        if ( d & 1 )
//            *(binario+count) = 1 + '0';
//        else
//            *(binario+count) = 0 + '0';
//
//        count++;
//    }
//    *(binario+count) = '\0';
//    printf("Tamanho: %d\n", count);
//    return  binario;
//}
//


